package fms.core;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串辅助类
 *
 * @author GuoXY
 */
public class StringUtil {
    /**
     * 前（填充位置，适用于本类方法fillStr、sideTrim）
     */
    public static final int FRONT = 10;

    /**
     * 后（填充位置，适用于本类方法fillStr、sideTrim）
     */
    public static final int BACK = 30;

    /**
     * 前后双向（填充位置，适用于本类方法fillStr）
     */
    public static final int BOTH = 20;

    /**
     * 填充字符串至指定长度
     *
     * @param source    原始字符串
     * @param totalLen  填充后长度
     * @param direction 填充位置（前或后，参照本类常量）
     * @param fillStr   填充字符
     * @return 填充后字符串
     */
    public static String fillStr(String source, int totalLen, int direction, String fillStr) throws Exception {
        //验证数据
        if (totalLen < 1) {
            throw new Exception("填充长度不能小于1！");
        }
        if (direction != FRONT && direction != BACK) {
            throw new Exception("该填充位置不存在！");
        }
        if (fillStr == null || "".equals(fillStr)) {
            throw new Exception("填充字符不能为空！");
        }
        if (fillStr.length() != 1) {
            throw new Exception("填充字符长度不得大于1！");
        }
        /*
		 * 填充
		 * 1、若待填充字符串为NULL，则返回长度为arg1，且各字符为arg3的字符串
		 * 2、若代填充字符串长度大于等于填充长度，则返回待填充字符串本身
		 */
        String strResult = source == null ? "" : source;
        strResult = strResult.trim();
        if (strResult.length() >= totalLen) {
            return strResult;
        }
        //填充长度
        int lenFill = totalLen - strResult.length();
        if (direction == 10) {
            //前部填充
            for (int i = 0; i < lenFill; i++) {
                strResult = fillStr + strResult;
            }
        } else {
            //后部填充
            for (int i = 0; i < lenFill; i++) {
                strResult += fillStr;
            }
        }
        return strResult;
    }

    /**
     * <pre>
     *  去掉指定字符串的开头和结尾的指定字符
     * </pre>
     *
     * @param source    要处理的字符串
     * @param direction 填充位置（前或后，参照本类常量）
     * @param trimstr   要去掉的字符串
     * @return 处理后的字符串
     * @description 以正则的方式，从前至后匹配，求出匹配终止位置，以此为起点截取后续字符串
     */
    public static String sideTrim(String source, int direction, String trimstr) throws Exception {
        // null或者空字符串的时候不处理
        if (source == null || source.length() == 0 || trimstr == null || trimstr.length() == 0) {
            return source;
        }
        if (direction != FRONT && direction != BACK && direction != BOTH) {
            throw new Exception("该填充位置不存在！");
        }

        // 结束位置
        int epos = 0;

        // 正规表达式
        String regpattern = "[" + trimstr + "]*+";
        Pattern pattern = Pattern.compile(regpattern, Pattern.CASE_INSENSITIVE);

        Matcher matcher = null;
        // 去掉结尾的指定字符
        if ((direction == BACK) || (direction == BOTH)) {
            StringBuffer buffer = new StringBuffer(source).reverse();
            matcher = pattern.matcher(buffer);
            if (matcher.lookingAt()) {
                epos = matcher.end();
                source = new StringBuffer(buffer.substring(epos)).reverse().toString();
            }
        }

        // 去掉开头的指定字符
        if ((direction == FRONT) || (direction == BOTH)) {
            matcher = pattern.matcher(source);
            if (matcher.lookingAt()) {
                epos = matcher.end();
                source = source.substring(epos);
            }
        }

        // 返回处理后的字符串
        return source;
    }

    // 将两个以字符串表示的整形数相加
    public static String strSum(String str1, String str2) {
        Integer sum = 0;
        if (str1 != null && str2 != null) {
            sum = Integer.parseInt(str1) + Integer.parseInt(str2);
        }
        return sum.toString();
    }

    // 删除“空白行”
    public static Object[] RemoveEmptyLine(String[] lines) {
        List<String> result = new ArrayList();
        for (String item : lines) {
//            System.out.println(item);
            if (!ObjectUtil.isBlank(item) && !ObjectUtil.isBlank(item.trim())) {
                result.add(item);
            }
        }
        return result.toArray();
    }

    // 一般在我们使用JDBC拼接SQL时，使用
    public static String addPercent(String searchCondition) {
        if (searchCondition != null) {
            searchCondition = "%" + searchCondition + "%";
        }
        return searchCondition;
    }

    // 获取两个%中间的字符串
    public static String subPercent(String searchCondition) {
        if (searchCondition != null) {
            int beginIndex = searchCondition.indexOf("%") + 1;
            int endIndex = searchCondition.lastIndexOf("%");
            searchCondition = searchCondition.substring(beginIndex, endIndex);
        }
        return searchCondition;
    }

    // 删除字符串前后的空白符
    public static String trimVal(String searchCondition) {
        if (searchCondition != null) {
            searchCondition = searchCondition.trim();
        }
        return searchCondition;
    }
}
